package com.docparser.processor;

/**
 * 数学公式转换测试类。
 * 用于验证公式转换的正确性。
 */
public class MathFormulaTest {
    public static void main(String[] args) {
        try {
            // 测试直接的上标转换
            testSuperscript();
            
            // 测试文件路径
            String testFile = "b.docx";
            
            // 创建文档处理器
            DocxProcessor processor = new DocxProcessor(testFile);
            
            System.out.println("\n开始测试文件公式转换...");
            System.out.println("测试文件: " + testFile);
            
            // 处理文档中的公式
            processor.process(formula -> {
                System.out.println("\n============= 公式分析 =============");
                System.out.println("原始LaTeX公式: " + formula);
                System.out.println("----------------------------------");
                
                // 验证常见公式类型
                validateFormula(formula);
                
                System.out.println("===================================\n");
            });
            
        } catch (Exception e) {
            System.err.println("测试过程中发生错误:");
            e.printStackTrace();
        }
    }
    
    /**
     * 验证公式并输出任何潜在问题
     */
    private static void validateFormula(String formula) {
        boolean hasErrors = false;
        
        // 检查括号匹配
        if (checkBrackets(formula)) {
            hasErrors = true;
        }
        
        // 检查数学函数
        if (checkMathFunctions(formula)) {
            hasErrors = true;
        }
        
        // 检查上下标
        if (checkScripts(formula)) {
            hasErrors = true;
        }
        
        // 检查特殊字符
        if (checkSpecialCharacters(formula)) {
            hasErrors = true;
        }
        
        if (!hasErrors) {
            System.out.println("✓ 未发现明显的格式问题");
        }
    }
    
    /**
     * 检查括号匹配情况
     * @return true 如果发现错误
     */
    private static boolean checkBrackets(String formula) {
        int curlyCount = 0;
        int squareCount = 0;
        int roundCount = 0;
        boolean hasError = false;
        
        for (char c : formula.toCharArray()) {
            switch (c) {
                case '{': curlyCount++; break;
                case '}': curlyCount--; break;
                case '[': squareCount++; break;
                case ']': squareCount--; break;
                case '(': roundCount++; break;
                case ')': roundCount--; break;
            }
            
            if (curlyCount < 0) {
                System.err.println("⚠ 错误: 找到未匹配的右花括号 }");
                curlyCount = 0; // 修复计数器
                hasError = true;
            }
            if (squareCount < 0) {
                System.err.println("⚠ 错误: 找到未匹配的右方括号 ]");
                squareCount = 0; // 修复计数器
                hasError = true;
            }
            if (roundCount < 0) {
                System.err.println("⚠ 错误: 找到未匹配的右圆括号 )");
                roundCount = 0; // 修复计数器
                hasError = true;
            }
        }
        
        if (curlyCount > 0) {
            System.err.println("⚠ 错误: 有 " + curlyCount + " 个未闭合的左花括号 {");
            hasError = true;
        }
        if (squareCount > 0) {
            System.err.println("⚠ 错误: 有 " + squareCount + " 个未闭合的左方括号 [");
            hasError = true;
        }
        if (roundCount > 0) {
            System.err.println("⚠ 错误: 有 " + roundCount + " 个未闭合的左圆括号 (");
            hasError = true;
        }
        
        return hasError;
    }
    
    /**
     * 检查数学函数格式
     * @return true 如果发现错误
     */
    private static boolean checkMathFunctions(String formula) {
        boolean hasError = false;
        String[] commonFunctions = {
            "\\sin", "\\cos", "\\tan", "\\cot", "\\sec", "\\csc",
            "\\arcsin", "\\arccos", "\\arctan", "\\sqrt", "\\sum",
            "\\prod", "\\int", "\\lim"
        };
        
        for (String func : commonFunctions) {
            if (formula.contains(func)) {
                // 检查函数后是否有参数
                int index = formula.indexOf(func);
                while (index != -1) {
                    if (index + func.length() < formula.length()) {
                        char nextChar = formula.charAt(index + func.length());
                        // 改进检查逻辑：允许小括号、花括号、空格、下标和上标
                        if (nextChar != '{' && nextChar != '(' && nextChar != ' ' &&
                            nextChar != '_' && nextChar != '^' && nextChar != '\\') {
                            System.err.println("⚠ 警告: " + func + " 后应该使用括号或空格");
                            hasError = true;
                        }
                    }
                    index = formula.indexOf(func, index + 1);
                }
            }
        }
        return hasError;
    }
    
    /**
     * 检查上下标格式
     * @return true 如果发现错误
     */
    private static boolean checkScripts(String formula) {
        boolean hasError = false;
        
        for (int i = 0; i < formula.length(); i++) {
            char c = formula.charAt(i);
            if (c == '^' || c == '_') {
                if (i + 1 >= formula.length()) {
                    System.err.println("⚠ 错误: " + c + " 后缺少内容");
                    hasError = true;
                    continue;
                }
                
                char next = formula.charAt(i + 1);
                if (next != '{' && !Character.isLetterOrDigit(next)) {
                    System.err.println("⚠ 警告: " + c + " 后建议使用花括号");
                    hasError = true;
                }
            }
        }
        
        return hasError;
    }
    
    /**
     * 测试上标转换
     */
    private static void testSuperscript() {
        System.out.println("\n=== 测试常见数学公式转换 ===\n");
        
        // 基础运算测试
        String[] basicFormulas = {
            "a + b - c",                          // 加减
            "a \\times b \\div c",                // 乘除
            "x^2 + y^2 = z^2",                   // 平方
            "\\sqrt{x^2 + y^2}",                 // 根号
        };
        
        // 分数测试
        String[] fractionFormulas = {
            "\\frac{a}{b}",                      // 简单分数
            "\\frac{x+1}{y-1}",                  // 复杂分数
            "\\frac{-b \\pm \\sqrt{b^2-4ac}}{2a}", // 二次方程
            "{-b \\pm \\sqrt{b^2-4ac}}\\over{2a}", // 使用\\over的二次方程
            "x={-b \\pm \\sqrt{b^2-4ac}}\\over 2a"  // 不带花括号的\\over形式
        };
        
        // 三角函数测试
        String[] trigFormulas = {
            "\\sin(\\theta)",                    // 基本三角函数
            "\\cos^2(x) + \\sin^2(x) = 1",      // 三角恒等式
            "\\tan(x) = \\frac{\\sin(x)}{\\cos(x)}" // 三角函数关系
        };
        
        // 特殊符号测试
        String[] specialFormulas = {
            "\\alpha + \\beta = \\gamma",        // 希腊字母
            "x \\leq y \\leq z",                 // 不等式
            "\\infty > x > -\\infty"            // 无穷
        };
        
        // 组合公式测试
        String[] complexFormulas = {
            "\\sum_{i=1}^n i^2",                // 求和
            "\\int_a^b f(x)dx",                 // 积分
            "\\lim_{x \\to \\infty} \\frac{1}{x} = 0" // 极限
        };
        
        // 测试所有公式
        System.out.println("基础运算测试：");
        testFormulaGroup(basicFormulas);
        
        System.out.println("\n分数测试：");
        testFormulaGroup(fractionFormulas);
        
        System.out.println("\n三角函数测试：");
        testFormulaGroup(trigFormulas);
        
        System.out.println("\n特殊符号测试：");
        testFormulaGroup(specialFormulas);
        
        System.out.println("\n组合公式测试：");
        testFormulaGroup(complexFormulas);
    }
    
    private static void testFormulaGroup(String[] formulas) {
        for (String formula : formulas) {
            System.out.println("\n测试公式: " + formula);
            validateFormula(formula);
        }
    }

    /**
     * 检查特殊字符格式
     * @return true 如果发现错误
     */
    private static boolean checkSpecialCharacters(String formula) {
        boolean hasError = false;
        
        // 检查度数符号
        if (formula.contains("°")) {
            System.err.println("⚠ 警告: 度数符号 ° 应该使用 ^{\\circ} 表示");
            hasError = true;
        }
        
        // 检查乘号
        if (formula.contains("×")) {
            System.err.println("⚠ 警告: 乘号 × 应该使用 \\times 表示");
            hasError = true;
        }
        
        // 检查点乘
        if (formula.contains("·")) {
            System.err.println("⚠ 警告: 点乘 · 应该使用 \\cdot 表示");
            hasError = true;
        }
        
        // 检查破折号
        if (formula.contains("—")) {
            System.err.println("⚠ 警告: 破折号应该使用 - 表示");
            hasError = true;
        }
        
        return hasError;
    }
}
